package com.dkd.manage.service.impl;

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import com.dkd.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.dkd.manage.mapper.SkuClassMapper;
import com.dkd.manage.domain.SkuClass;
import com.dkd.manage.service.ISkuClassService;
import com.dkd.common.exception.ServiceException;

/**
 * 商品分类Service业务层处理
 *
 * @author ruoyi
 * @date 2025-11-10
 */
@Service
public class SkuClassServiceImpl implements ISkuClassService
{
    @Autowired
    private SkuClassMapper skuClassMapper;

    /**
     * 查询商品分类
     *
     * @param id 商品分类主键
     * @return 商品分类
     */
    @Override
    public SkuClass selectSkuClassById(Long id)
    {
        return skuClassMapper.selectSkuClassById(id);
    }

    /**
     * 查询商品分类列表
     *
     * @param skuClass 商品分类
     * @return 商品分类
     */
    @Override
    public List<SkuClass> selectSkuClassList(SkuClass skuClass)
    {
        return skuClassMapper.selectSkuClassList(skuClass);
    }

    /**
     * 查询商品分类树形结构
     *
     * @param skuClass 商品分类
     * @return 商品分类树
     */
    @Override
    public List<SkuClass> selectSkuClassTree(SkuClass skuClass)
    {
        List<SkuClass> skuClasses = skuClassMapper.selectSkuClassTree(skuClass);
        return buildSkuClassTree(skuClasses);
    }

    /**
     * 新增商品分类
     *
     * @param skuClass 商品分类
     * @return 结果
     */
    @Override
    @Transactional
    public int insertSkuClass(SkuClass skuClass)
    {
        skuClass.setCreateTime(DateUtils.getNowDate());
        return skuClassMapper.insertSkuClass(skuClass);
    }

    /**
     * 修改商品分类
     *
     * @param skuClass 商品分类
     * @return 结果
     */
    @Override
    @Transactional
    public int updateSkuClass(SkuClass skuClass)
    {
        skuClass.setUpdateTime(DateUtils.getNowDate());
        return skuClassMapper.updateSkuClass(skuClass);
    }

    /**
     * 批量删除商品分类
     *
     * @param ids 需要删除的商品分类主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSkuClassByIds(Long[] ids)
    {
        for (Long id : ids)
        {
            // 检查是否有子分类
            int childCount = skuClassMapper.selectChildClassCount(id);
            if (childCount > 0)
            {
                throw new ServiceException("该分类下还有子分类，不能删除");
            }

            // 检查是否有商品
            int skuCount = skuClassMapper.selectSkuCountByClassId(id);
            if (skuCount > 0)
            {
                throw new ServiceException("该分类下还有商品，不能删除");
            }
        }
        return skuClassMapper.deleteSkuClassByIds(ids);
    }

    /**
     * 删除商品分类信息
     *
     * @param id 商品分类主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSkuClassById(Long id)
    {
        // 检查是否有子分类
        int childCount = skuClassMapper.selectChildClassCount(id);
        if (childCount > 0)
        {
            throw new ServiceException("该分类下还有子分类，不能删除");
        }

        // 检查是否有商品
        int skuCount = skuClassMapper.selectSkuCountByClassId(id);
        if (skuCount > 0)
        {
            throw new ServiceException("该分类下还有商品，不能删除");
        }

        return skuClassMapper.deleteSkuClassById(id);
    }

    /**
     * 构建树形结构
     *
     * @param skuClasses 分类列表
     * @return 树形结构
     */
    @Override
    public List<SkuClass> buildSkuClassTree(List<SkuClass> skuClasses)
    {
        List<SkuClass> returnList = new ArrayList<SkuClass>();
        List<Long> tempList = new ArrayList<Long>();
        for (SkuClass skuClass : skuClasses)
        {
            tempList.add(skuClass.getId());
        }
        for (Iterator<SkuClass> iterator = skuClasses.iterator(); iterator.hasNext();)
        {
            SkuClass skuClass = (SkuClass) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(skuClass.getParentId()))
            {
                recursionFn(skuClasses, skuClass);
                returnList.add(skuClass);
            }
        }
        if (returnList.isEmpty())
        {
            returnList = skuClasses;
        }
        return returnList;
    }

    /**
     * 递归列表
     */
    private void recursionFn(List<SkuClass> list, SkuClass t)
    {
        // 得到子节点列表
        List<SkuClass> childList = getChildList(list, t);
        t.setChildren(childList);
        for (SkuClass tChild : childList)
        {
            if (hasChild(list, tChild))
            {
                recursionFn(list, tChild);
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private List<SkuClass> getChildList(List<SkuClass> list, SkuClass t)
    {
        List<SkuClass> tlist = new ArrayList<SkuClass>();
        Iterator<SkuClass> it = list.iterator();
        while (it.hasNext())
        {
            SkuClass n = (SkuClass) it.next();
            if (n.getParentId() != null && n.getParentId().longValue() == t.getId().longValue())
            {
                tlist.add(n);
            }
        }
        return tlist;
    }

    /**
     * 判断是否有子节点
     */
    private boolean hasChild(List<SkuClass> list, SkuClass t)
    {
        return getChildList(list, t).size() > 0 ? true : false;
    }
}